// --------------- 定义所有在操作 Router 时可能用到的工具函数

// 从一个 MenuList 里查找指定 id 的 menu，支持多级递归查询
import {useSettingStore} from "../store/setting";
import {useAppStore} from "../store/app";
const serverUrl = import.meta.env.VITE_SERVER_URL;

export const findMenuById = function(menuList, id) {
    for (var i = 0; i < menuList.length; i++) {
        var menu = menuList[i];
        if(menu.id + '' === id + '') {
            return menu;
        }
        // 如果是二级或多级
        if(menu.children) {
            var menu2 = findMenuById(menu.children, id);
            if(menu2) {
                return menu2;
            }
        }
    }
    return null;
};

// 将一维平面数组转换为 Tree 菜单 (根据其指定的 parentId 添加到其父菜单的 children)
export const arrayToTree = function(menuList) {
    for (var i = 0; i < menuList.length; i++) {
        var menu = menuList[i];
        // 如果这个 Menu 指定了 parentId 属性，则将其转移到其指定的父 Menu 的 children 属性上
        if(menu.parentId) {
            var parentMenu = findMenuById(menuList, menu.parentId);
            if(parentMenu) {
                menu.parentMenu = parentMenu;
                parentMenu.children = parentMenu.children || [];
                parentMenu.children.push(menu);
                menuList.splice(i, 1);	// 从一维中删除
                i--;
            } else {
                // 如果指定了 parentId 但又没找到 parentMenu，也一样将其隐藏 
                if(menu.parentId !== '-1' && menu.parentId !== -1) {
                    menuList.splice(i, 1);	// 从一维中删除
                    i--;
                }
            }
        }
    }
    return menuList;
};

// 返回菜单集合的 一维数组 形式 （将树形菜单转化为一维数组并返回） 方便遍历
export const treeToArray = function(menuList) {
    var arr = [];
    function _dg(_menuList) {
        _menuList = _menuList || [];
        for (var i = 0; i < _menuList.length; i++) {
            var menu = _menuList[i];
            arr.push(menu);
            // 如果有子菜单
            if(menu.children) {
                _dg(menu.children);
            }
        }
    }
    _dg(menuList);
    return arr;
};

// 获取菜单的所有id
export const getAllId = function(menuList) {
    var arr = [];
    treeToArray(menuList).forEach(function(item) {
        arr.push(item.id);
    });
    return arr;
};

// 根据 url 获取文件后缀
export const getUrlExt = function(url) {
    if(!url) {
        return "";
    }
    if(url.indexOf('?') > -1) {
        url = url.split('?')[0];
    }
    if(url.indexOf('#') > -1) {
        url = url.split('#')[0];
    }
    var index= url.lastIndexOf(".");
    if(index === -1) {
        return "";
    }
    return url.substr(index + 1);
};

// 从数组中删除指定元素
export const arrayDelete = function(arr, item){
    if(item instanceof Array) {
        for (let i = 0; i < item.length; i++) {
            let ite = item[i];
            let index = arr.indexOf(ite);
            if (index > -1) {
                arr.splice(index, 1);
            }
        }
    } else {
        var index = arr.indexOf(item);
        if (index > -1) {
            arr.splice(index, 1);
        }
    }
}

// 返回一个 iframe 视图 (此方法构建的视图会在打包后不显示，原因未知)
export const getIframeView = function (name, url) {
    return {
        name: name,
        template: `<div><iframe class="iframe-view" src="${url}" /></div>`
    }
}

// 返回随机数
export const randomNum = function(min, max) {
    min = min || 1;
    max = max || 1000000000;
    return parseInt(Math.random() * (max - min + 1) + min, 10);
};

// 定义菜单的方法，此方法不会转换数据结构，只会为 menu 补上一些默认值
export const defineMenu = function (_menuList) {
    for (let menu of _menuList) {
        // 如果是一个父菜单，则递归解析
        if(menu.children) {
            menu.children = defineMenu(menu.children);
            continue;
        }

        // 缺少必要属性时，不再加工数据
        if (menu.title === undefined) {
            continue;
        }

        // 创建一些必要的属性
        menu.id = menu.id + '';
        menu.name = menu.name || menu.id;
        menu.path = menu.path || '/' + menu.id;
        menu.show = menu.show || 'auth';
        // menu.jumpPath = menu.path;
        menu.meta = menu.meta || {};
        if(menu.url) {
            if(menu.url.indexOf('${SERVER_URL}') === 0) {
                menu.url = menu.url.replace('${SERVER_URL}', serverUrl);
            }
        }

        // 如果指定了 menu.componentPath 值，则强制其以 /@/ 开头
        if(menu.componentPath) {
            if(menu.componentPath.indexOf("/@") === 0) {
                
            } else if (menu.componentPath.indexOf("@") === 0) {
                menu.componentPath = "/" + menu.componentPath;
            } else {
                menu.componentPath = "/@" + menu.componentPath;
            }
            // menu.component = () => import(/* @vite-ignore */menu.componentPath);
        }

        // 如果是 iframe 视图，则创建对应的 component
        if(menu.url && menu.isBlank !== true) {
            // menu.component = getIframeView(menu.name, menu.url);
            menu.meta.iframeUrl = menu.url;
            menu.component = () => import('../layout/view/iframe-view');
        }

    }
    return _menuList;
}

// path 与 Route 的对应关系表
// 由于在初始界面时，vue-router 获取到的 route 对象读取不到 meta 元信息，尚未不知道是bug还是框架故意而为之，所以这里自建映射关系表，以便后续操作 
const pathRouteMap = {};

// 写入 path 与 Route 对象的映射  
export const setRouteByPath = function(path, route) {
    pathRouteMap[path] = route;
}

// 根据 path 寻找对应的 Route 对象 
export const getRouteByPath = function(path) {
    return pathRouteMap[path];
}

// 将提供 Menu 菜单对象，翻译为 vue-router 需要的 Route 路由对象，并提供回调函数操作 
export const menuToRouter = function(_menuList, callback) {
    for (let menu of _menuList) {
        // 如果是一个父菜单，则递归解析
        if(menu.children) {
            menuToRouter(menu.children, callback);
            continue;
        }

        // 如果不是一个路由，而仅仅只是一个菜单
        if (menu.title === undefined || menu.component === undefined) {    //  || menu.path === undefined ||
            continue;
        }

        // 创建此 Menu 对应的 Route
        const route = {
            name: menu.name,
            path: menu.path,
            component: menu.component,
            meta: {
                ... (menu.meta || {}),
                menu: menu
            },
        }

        // 写入 path 与 Route 对象的映射  
        setRouteByPath(route.path, route);

        // 调用回调函数操作 
        if(callback) {
            callback(route);
        }
    }
    return _menuList;
}


// 设置网页标题
export const setTitle = function (route) {
    if(route.meta.menu) {
        document.title = route.meta.menu.title + ' - ' + useSettingStore().title;
    }
}

// 判断一个菜单是否应该显示
export const menuIsShow = function (menu) {
    if(menu.show === 'yes') {
        return true;
    }
    if(menu.show === 'no') {
        return false;
    }
    return useAppStore().showList.indexOf(menu.id) > -1;
}

// 判断一个菜单是否为目录
export const menuIsDir = function (menu) {
    // 如果强制指定了是一个目录，则直接返回 true
    if(menu.type === 'dir') {
        return true;
    }
    
    // 如果存在子菜单
    if (menu.children) {
        // 如果存在 component、url、type=btn，则依然认定还是子菜单
        if(menu.component || menu.url || menu.type === 'btn') {
            return false;
        }
        return true;
    } else {
        // 不存在 children 属性，必为子菜单 
        return false;
    }
}

